#include "../include/Message.h"
#include <iostream>
#include <sstream>
#include <cstring>

// TLV序列化：将Message对象转换为二进制数据
std::string Message::serialize() const
{
    std::string data;

    // 序列化tag (4字节)
    data.append(reinterpret_cast<const char *>(&tag), sizeof(tag));

    // 序列化length (4字节)
    data.append(reinterpret_cast<const char *>(&length), sizeof(length));

    // 序列化value (length字节)
    data.append(value);

    return data;
}

// TLV反序列化：从二进制数据解析为Message对象
Message Message::deserialize(const std::string &data)
{
    Message msg;

    // 检查数据长度是否足够
    if (data.size() < sizeof(msg.tag) + sizeof(msg.length))
    {
        std::cerr << "错误: 数据长度不足，无法解析TLV头部" << std::endl;
        return msg;
    }

    size_t offset = 0;

    // 解析tag (4字节)
    std::memcpy(&msg.tag, data.data() + offset, sizeof(msg.tag));
    offset += sizeof(msg.tag);

    // 解析length (4字节)
    std::memcpy(&msg.length, data.data() + offset, sizeof(msg.length));
    offset += sizeof(msg.length);

    // 检查数据长度是否完整
    if (data.size() < offset + msg.length)
    {
        std::cerr << "错误: 数据长度不完整，期望 " << (offset + msg.length)
                  << " 字节，实际 " << data.size() << " 字节" << std::endl;
        return msg;
    }

    // 解析value
    msg.value = data.substr(offset, msg.length);

    return msg;
}

// 检查是否是一个完整的TLV数据包
bool Message::isCompletePacket(const std::string &data, size_t &packet_len)
{
    // 检查是否有足够的字节读取TLV头部 (tag + length = 8字节)
    if (data.size() < sizeof(int) * 2)
    {
        packet_len = 0;
        return false;
    }

    int tag, length;

    // 读取tag和length
    std::memcpy(&tag, data.data(), sizeof(tag));
    std::memcpy(&length, data.data() + sizeof(tag), sizeof(length));

    // 计算完整包长度: tag(4) + length(4) + value(length)
    size_t total_len = sizeof(tag) + sizeof(length) + length;

    // 检查数据是否足够
    if (data.size() >= total_len)
    {
        packet_len = total_len;
        return true;
    }
    else
    {
        packet_len = total_len;
        return false;
    }
}